home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / SCIENTIF / H381.ZIP / GSRC208A.ZIP / GEP1.C < prev    next >
C/C++ Source or Header  |  1993-07-07  |  18KB  |  621 lines
  1. #include "copyleft.h"
  2.  
  3. /*
  4.     GEPASI - a simulator of metabolic pathways and other dynamical systems
  5.     Copyright (C) 1989, 1992  Pedro Mendes
  6. */
  7.  
  8. /*************************************/
  9. /*                                   */
  10. /*          GWTOP - Topology         */
  11. /*        MS-WINDOWS front end       */
  12. /*                                   */
  13. /*       Initialization and some     */
  14. /*           data structures         */
  15. /*                                   */
  16. /*           QuickC/WIN 1.0          */
  17. /*                                   */
  18. /*   (include here compilers that    */
  19. /*   compiled GWSIM successfully)    */
  20. /*                                   */
  21. /*************************************/
  22.  
  23.  
  24. #include <windows.h>
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include <stdio.h>
  28. #include <io.h>
  29. #include <sys\types.h>
  30. #include <sys\stat.h>
  31. #include "globals.h"
  32. #include "topgvar.h"
  33. #include "strtbl.h"
  34. #include "gwtop.h"
  35. #include "iotop.h"
  36.  
  37. struct kint {
  38.                   unsigned char nsub;
  39.                 unsigned char npro;
  40.                 unsigned char nmodf;
  41.                 unsigned char revers;
  42.                 int idx;
  43.                 LPSTR descr;
  44.                };
  45.  
  46. struct nodet{
  47.              char item;
  48.              unsigned char val;
  49.              unsigned char left;
  50.              unsigned char right;
  51.             } ;
  52.  
  53. struct treet{
  54.              struct nodet node[256];
  55.              char id[64][10];
  56.              float constant[32];
  57.              int nnode,
  58.                  nnum,
  59.                  nid,
  60.                  nsub,
  61.                  npro,
  62.                  nmodf,
  63.                  nconst,
  64.                  revers;
  65.              char descr[64];
  66.             } ;
  67.  
  68.  
  69. GLOBALHANDLE hMetname;                                /* handle to memory block w/ metname    */
  70. GLOBALHANDLE hStepname;                                /* handle to memory block w/ stepname    */
  71. GLOBALHANDLE hStoiu;                                /* handle to memory block w/ stoiu        */
  72. GLOBALHANDLE hLoop;                                    /* handle to memory block w/ loop        */
  73. GLOBALHANDLE hKtype;                                /* handle to memory block w/ ktype        */
  74. GLOBALHANDLE hRstr;                                    /* handle to memory block w/ rstr        */
  75. GLOBALHANDLE hTree;                                    /* handle to memory block w/ tree        */
  76.  
  77. char    (huge *metname)[NAME_L];                    /* pointer to work with metname array    */
  78. char    (huge *stepname)[NAME_L];                    /* metabolite names                        */
  79. int        huge *stoiu;                                /* pointer to work with metname array    */
  80. unsigned char (huge *loop)[MAX_STEP][MAX_MET];        /* def. of modification loops            */
  81. int     (huge *rstr)[MAX_STEP][MAX_MOL];            /* reaction structure                    */
  82. char    topname[256];                                /* title for the topology                */
  83. double    xu[MAX_MET];                                /* concentrations at time t user        */
  84. int        intmet[MAX_MET];                            /* 1 if internal metabolite                */
  85. unsigned char    revers[MAX_STEP];                    /* 1 if reaction is reversible            */
  86. int        kinetu[MAX_STEP];                            /* type of kinetics (user numb.)        */
  87. int        kfl[MAX_STEP];                                /* flags for input of user-def.kinetics */
  88. unsigned char    nmod[MAX_STEP];                        /* number of assigned modfs of a react.    */
  89. struct    kint huge *ktype;                            /* ptr array of kinetic types & proprt    */
  90. double    endtime;                                    /* time value for last iteration        */
  91. double    hrcz;                                        /* highest rate considered zero            */
  92. double    dft_endtime;                                /* time value for last iteration        */
  93. double    dft_hrcz;                                    /* highest rate considered zero            */
  94. float    ver_no;                                        /* .top and .sim version number            */
  95. int        totmet;                                        /* number of total metabolites            */
  96. int        nmetab;                                        /* number of internal metabolites        */
  97. int        nsteps;                                        /* number of steps                        */
  98. int        nloops;                                        /* number of modifier loops             */
  99. int        nrateq;                                        /* number of kinetic types in the datab */
  100. int        newtree;                                    /* 1 if user added kinetic new types    */
  101. int        nudf;                                        /* number of user-defined kin. types    */
  102. int        debugval;                                    /* debug mode                            */
  103. int        dft_debugval;                                /* debug mode                            */
  104. int        options;                                    /* various options                        */
  105. struct    treet huge *tree;                            /* function tree for rate equations        */
  106. struct    treet tr;                                    /* tree for the input                    */
  107.  
  108. /* Initialization of GEPASI's variables */
  109.  
  110. int InitGepasiVar( void )
  111. {
  112.  int i, j;
  113.  
  114.  hMetname = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD) MAX_MET * NAME_L * sizeof( char ) );
  115.  if( hMetname == NULL ) return -1;
  116.  
  117.  hStepname = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD) MAX_STEP * NAME_L * sizeof( char ) );
  118.  if( hStepname == NULL )
  119.  {
  120.   GlobalFree( hMetname );
  121.   return -1;
  122.  }
  123.  
  124.  hStoiu = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD) MAX_MET * MAX_STEP * sizeof( int ) );
  125.  if( hStoiu == NULL )
  126.  {
  127.   GlobalFree( hMetname );
  128.   GlobalFree( hStepname );
  129.   return -1;
  130.  }
  131.  
  132.  hLoop = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD) MAX_STEP * MAX_MET * sizeof( unsigned char ) );
  133.  if( hLoop == NULL )
  134.  {
  135.   GlobalFree( hMetname );
  136.   GlobalFree( hStepname );
  137.   GlobalFree( hStoiu );
  138.   return -1;
  139.  }
  140.  
  141.  hKtype = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD) MAX_TYP * sizeof( struct kint ) );
  142.  if( hKtype == NULL )
  143.  {
  144.   GlobalFree( hMetname );
  145.   GlobalFree( hStepname );
  146.   GlobalFree( hStoiu );
  147.   GlobalFree( hLoop );
  148.   return -1;
  149.  }
  150.  
  151.  hRstr = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD) MAX_MOL * MAX_STEP * sizeof( int ) );
  152.  if( hRstr == NULL )
  153.  {
  154.   GlobalFree( hMetname );
  155.   GlobalFree( hStepname );
  156.   GlobalFree( hStoiu );
  157.   GlobalFree( hLoop );
  158.   GlobalFree( hKtype );
  159.   return -1;
  160.  }
  161.  
  162.  nudf = 0;
  163.  hTree = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD) sizeof( struct treet ) );
  164.  if( hTree == NULL )
  165.  {
  166.   GlobalFree( hMetname );
  167.   GlobalFree( hStepname );
  168.   GlobalFree( hStoiu );
  169.   GlobalFree( hLoop );
  170.   GlobalFree( hKtype );
  171.   GlobalFree( hRstr );
  172.   return -1;
  173.  }
  174.  
  175.  metname    = ( char (huge *)[NAME_L] ) GlobalLock( hMetname );
  176.  stepname    = ( char (huge *)[NAME_L] ) GlobalLock( hStepname );
  177.  stoiu        = ( int huge * ) GlobalLock( hStoiu );
  178.  loop        = ( unsigned char (huge *)[MAX_STEP][MAX_MET] ) GlobalLock( hLoop );
  179.  ktype        = ( struct kint huge * ) GlobalLock( hKtype );
  180.  rstr        = ( int (huge *)[MAX_STEP][MAX_MOL] ) GlobalLock( hRstr );
  181.  tree        = ( struct treet huge * ) GlobalLock( hTree );
  182.  
  183.  newtree = 0;
  184.  
  185.  for( i=0; i<MAX_MET; i++ ) intmet[i] = 1;            /* set all metb. to be internal    */
  186.  totmet = nmetab = nsteps = 0;                        /* clear no. of metb. and steps    */
  187.  
  188.  nrateq = MAX_TYP;                                  /* set the no. of kinetic types */
  189.  ktype[NOT].nsub = 0;                                /* init info of kinetic types    */
  190.  ktype[NOT].npro = 0;
  191.  ktype[NOT].revers = -1;
  192.  ktype[NOT].nmodf = 0;
  193.  ktype[NOT].descr = (LPSTR) "<not defined>";
  194.  ktype[I01].nsub = 0;
  195.  ktype[I01].npro = 0;
  196.  ktype[I01].revers = 0;
  197.  ktype[I01].nmodf = 0;
  198.  ktype[I01].descr = (LPSTR) "constant rate";
  199.  ktype[I10].nsub = 20;
  200.  ktype[I10].npro = 20;
  201.  ktype[I10].revers = 0;
  202.  ktype[I10].nmodf = 0;
  203.  ktype[I10].descr = (LPSTR) "no type";
  204.  ktype[I11].nsub = 1;
  205.  ktype[I11].npro = 1;
  206.  ktype[I11].revers = 0;
  207.  ktype[I11].nmodf = 0;
  208.  ktype[I11].descr = (LPSTR) "mass action";
  209.  ktype[R11].nsub = 1;
  210.  ktype[R11].npro = 1;
  211.  ktype[R11].revers = 1;
  212.  ktype[R11].nmodf = 0;
  213.  ktype[R11].descr = (LPSTR) ktype[I11].descr;
  214.  ktype[I21].nsub = 2;
  215.  ktype[I21].npro = 1;
  216.  ktype[I21].revers = 0;
  217.  ktype[I21].nmodf = 0;
  218.  ktype[I21].descr = (LPSTR) ktype[I11].descr;
  219.  ktype[R21].nsub = 2;
  220.  ktype[R21].npro = 1;
  221.  ktype[R21].revers = 1;
  222.  ktype[R21].nmodf = 0;
  223.  ktype[R21].descr = (LPSTR) ktype[I11].descr;
  224.  ktype[I12].nsub = 1;
  225.  ktype[I12].npro = 2;
  226.  ktype[I12].revers = 0;
  227.  ktype[I12].nmodf = 0;
  228.  ktype[I12].descr = (LPSTR) ktype[I11].descr;
  229.  ktype[R12].nsub = 1;
  230.  ktype[R12].npro = 2;
  231.  ktype[R12].revers = 1;
  232.  ktype[R12].nmodf = 0;
  233.  ktype[R12].descr = (LPSTR) ktype[I11].descr;
  234.  ktype[I31].nsub = 3;
  235.  ktype[I31].npro = 1;
  236.  ktype[I31].revers = 0;
  237.  ktype[I31].nmodf = 0;
  238.  ktype[I31].descr = (LPSTR) ktype[I11].descr;
  239.  ktype[R31].nsub = 3;
  240.  ktype[R31].npro = 1;
  241.  ktype[R31].revers = 1;
  242.  ktype[R31].nmodf = 0;
  243.  ktype[R31].descr = (LPSTR) ktype[I11].descr;
  244.  ktype[I13].nsub = 1;
  245.  ktype[I13].npro = 3;
  246.  ktype[I13].revers = 0;
  247.  ktype[I13].nmodf = 0;
  248.  ktype[I13].descr = (LPSTR) ktype[I11].descr;
  249.  ktype[R13].nsub = 1;
  250.  ktype[R13].npro = 3;
  251.  ktype[R13].revers = 1;
  252.  ktype[R13].nmodf = 0;
  253.  ktype[R13].descr = (LPSTR) ktype[I11].descr;
  254.  ktype[I22].nsub = 2;
  255.  ktype[I22].npro = 2;
  256.  ktype[I22].revers = 0;
  257.  ktype[I22].nmodf = 0;
  258.  ktype[I22].descr = (LPSTR) ktype[I11].descr;
  259.  ktype[R22].nsub = 2;
  260.  ktype[R22].npro = 2;
  261.  ktype[R22].revers = 1;
  262.  ktype[R22].nmodf = 0;
  263.  ktype[R22].descr = (LPSTR) ktype[I11].descr;
  264.  ktype[I32].nsub = 3;
  265.  ktype[I32].npro = 2;
  266.  ktype[I32].revers = 0;
  267.  ktype[I32].nmodf = 0;
  268.  ktype[I32].descr = (LPSTR) ktype[I11].descr;
  269.  ktype[R32].nsub = 3;
  270.  ktype[R32].npro = 2;
  271.  ktype[R32].revers = 1;
  272.  ktype[R32].nmodf = 0;
  273.  ktype[R32].descr = (LPSTR) ktype[I11].descr;
  274.  ktype[I23].nsub = 2;
  275.  ktype[I23].npro = 3;
  276.  ktype[I23].revers = 0;
  277.  ktype[I23].nmodf = 0;
  278.  ktype[I23].descr = (LPSTR) ktype[I11].descr;
  279.  ktype[R23].nsub = 2;
  280.  ktype[R23].npro = 3;
  281.  ktype[R23].revers = 1;
  282.  ktype[R23].nmodf = 0;
  283.  ktype[R23].descr = (LPSTR) ktype[I11].descr;
  284.  ktype[I33].nsub = 3;
  285.  ktype[I33].npro = 3;
  286.  ktype[I33].revers = 0;
  287.  ktype[I33].nmodf = 0;
  288.  ktype[I33].descr = (LPSTR) ktype[I11].descr;
  289.  ktype[R33].nsub = 3;
  290.  ktype[R33].npro = 3;
  291.  ktype[R33].revers = 1;
  292.  ktype[R33].nmodf = 0;
  293.  ktype[R33].descr = (LPSTR) ktype[I11].descr;
  294.  ktype[IMM].nsub = 1;
  295.  ktype[IMM].npro = 1;
  296.  ktype[IMM].revers = 0;
  297.  ktype[IMM].nmodf = 0;
  298.  ktype[IMM].descr = (LPSTR) "Michaelis-Menten";
  299.  ktype[RMM].nsub = 1;
  300.  ktype[RMM].npro = 1;
  301.  ktype[RMM].revers = 1;
  302.  ktype[RMM].nmodf = 0;
  303.  ktype[RMM].descr = (LPSTR) "reversible Michaelis-Menten";
  304.  ktype[PSI].nsub = 1;
  305.  ktype[PSI].npro = 1;
  306.  ktype[PSI].revers = 1;
  307.  ktype[PSI].nmodf = 1;
  308.  ktype[PSI].descr = (LPSTR) "specific inhibition";
  309.  ktype[PCI].nsub = 1;
  310.  ktype[PCI].npro = 1;
  311.  ktype[PCI].revers = 1;
  312.  ktype[PCI].nmodf = 1;
  313.  ktype[PCI].descr = (LPSTR) "catalytic inhibition";
  314.  ktype[MXI].nsub = 1;
  315.  ktype[MXI].npro = 1;
  316.  ktype[MXI].revers = 1;
  317.  ktype[MXI].nmodf = 1;
  318.  ktype[MXI].descr = (LPSTR) "mixed inhibition";
  319.  ktype[PSA].nsub = 1;
  320.  ktype[PSA].npro = 1;
  321.  ktype[PSA].revers = 1;
  322.  ktype[PSA].nmodf = 1;
  323.  ktype[PSA].descr = (LPSTR) "specific activation";
  324.  ktype[PCA].nsub = 1;
  325.  ktype[PCA].npro = 1;
  326.  ktype[PCA].revers = 1;
  327.  ktype[PCA].nmodf = 1;
  328.  ktype[PCA].descr = (LPSTR) "catalytic activation";
  329.  ktype[MXA].nsub = 1;
  330.  ktype[MXA].npro = 1;
  331.  ktype[MXA].revers = 1;
  332.  ktype[MXA].nmodf = 1;
  333.  ktype[MXA].descr = (LPSTR) "mixed activation";
  334.  ktype[GOM].nsub = 20;
  335.  ktype[GOM].npro = 20;
  336.  ktype[GOM].revers = 1;
  337.  ktype[GOM].nmodf = 1;
  338.  ktype[GOM].descr = (LPSTR) "Botts-Morales";
  339.  ktype[HIL].nsub = 1;
  340.  ktype[HIL].npro = 1;
  341.  ktype[HIL].revers = 0;
  342.  ktype[HIL].nmodf = 0;
  343.  ktype[HIL].descr = (LPSTR) "Hill";
  344.  ktype[RHL].nsub = 20;
  345.  ktype[RHL].npro = 20;
  346.  ktype[RHL].revers = 1;
  347.  ktype[RHL].nmodf = 0;
  348.  ktype[RHL].descr = (LPSTR) "reversible Hill";
  349.  ktype[UBS].nsub = 1;
  350.  ktype[UBS].npro = 2;
  351.  ktype[UBS].revers = 1;
  352.  ktype[UBS].nmodf = 0;
  353.  ktype[UBS].descr = (LPSTR) "Ordered Uni Bi (A=P+Q)";
  354.  ktype[UBM].nsub = 1;
  355.  ktype[UBM].npro = 1;
  356.  ktype[UBM].revers = 1;
  357.  ktype[UBM].nmodf = 0;
  358.  ktype[UBM].descr = (LPSTR) "Ordered Uni Bi (A=2*P)";
  359.  ktype[ALI].nsub = 1;
  360.  ktype[ALI].npro = 1;
  361.  ktype[ALI].revers = 1;
  362.  ktype[ALI].nmodf = 1;
  363.  ktype[ALI].descr = (LPSTR) "allosteric inhibition";
  364.  
  365.  if( (i = in_kinet()) )
  366.  {
  367.   LoadString( hInst, i, szString, sizeof(szString) );
  368.   MessageBeep( MB_ICONQUESTION );
  369.   MessageBox( NULL, szString, (LPSTR) "user-def.kin", MB_ICONINFORMATION );
  370.  }
  371.  return 0;
  372. }
  373.  
  374. /*
  375.    output error message from the lexical analyser
  376. */
  377.  
  378. int lexyy_fatal( char *m )
  379. {
  380.  MessageBeep( MB_OK );
  381.  MessageBox( NULL, (LPSTR) m, (LPSTR) "Lexical Analyser Error", MB_ICONINFORMATION );
  382.  return 0;
  383. }
  384.  
  385. /*
  386.    create a new function tree object
  387. */
  388.  
  389. int new_tree( int idx )
  390. {
  391.  if( !eqefl )
  392.  {
  393.   nudf++;
  394.   GlobalUnlock( hTree );
  395.   hTree = GlobalReAlloc( hTree, (DWORD) nudf * sizeof( struct treet ), GMEM_ZEROINIT | GMEM_MOVEABLE );
  396.   if( hTree == NULL )
  397.    return IDS_ERR_NOEXEC;
  398.   tree = ( struct treet huge * ) GlobalLock( hTree );
  399.  }
  400.  _fmemcpy( (void __far *) &tree[idx], (void __far *) &tr, sizeof( struct treet ) );
  401.  newtree = 1;
  402.  return 0;
  403. }
  404.  
  405. /*
  406.   count the number of substrates, etc. in the function tree
  407.   and allocate memory for the string with the title
  408. */
  409.  
  410. void tidy_tree( void )
  411. {
  412.  int i, l;
  413.  
  414.  for( tr.nsub =
  415.       tr.npro =
  416.       tr.nmodf =
  417.       tr.nconst =
  418.       i = 0; i<tr.nid; i++ )
  419.   switch( (int) tr.id[i][9] )
  420.   {
  421.    case 0: tr.nconst++; break;
  422.    case 1: tr.nsub++; break;
  423.    case 2: tr.npro++; break;
  424.    case 3: tr.nmodf++; break;
  425.   }
  426. }
  427.  
  428.  
  429. /*
  430.    read the user-defined kinetic types in the database
  431. */
  432.  
  433. int in_kinet( void )
  434. {
  435.  GLOBALHANDLE hTemp;
  436.  HANDLE hBuff;
  437.  OFSTRUCT OfStruct;
  438.  struct stat fst;
  439.  unsigned int bufsize;
  440.  char *Buff;
  441.  char fn[128], *ptr;
  442.  int ch1;
  443.  int nRc;
  444.  
  445.  /* make the complete pathname of user-def.kin            */
  446.  GetModuleFileName( hInst, (LPSTR) fn, sizeof( fn ) );
  447.  ptr = strrchr( fn, '\\' );
  448.  *(ptr+1) = '\0';
  449.  lstrcat( (LPSTR) fn, (LPSTR) "user-def.kin" );
  450.  
  451.  /* open the file                                                    */
  452.  ch1 = OpenFile( fn, &OfStruct, OF_READ );
  453.  if( ch1 != -1 )
  454.  {
  455.   /* get the file statistics                                        */
  456.   fstat( ch1, &fst );
  457.  
  458.   /* set the buffer to the size of the file plus one                */
  459.   bufsize = (unsigned int) fst.st_size;
  460.  
  461.   /* allocate space for the read buffer and lock it                    */
  462.   hBuff = LocalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE, (WORD) (bufsize+1) );
  463.   if( hBuff == NULL ) return IDS_ERR_NOEXEC;
  464.   Buff = (char *) LocalLock( hBuff );
  465.  
  466.   /*read the file and close it                                        */
  467.   if( read( ch1, Buff, bufsize ) == -1 )
  468.   {
  469.    LocalUnlock( hBuff );
  470.    LocalFree( hBuff );
  471.    return IDS_ERR_LOAD;
  472.   }
  473.   close( ch1 );
  474.  
  475.   for( ; ; )
  476.   {
  477.    /* look for a form-feed                                            */
  478.    Buff = strchr( Buff, '\f' );
  479.    if( Buff==NULL )
  480.    {
  481.     LocalUnlock( hBuff );
  482.     LocalFree( hBuff );
  483.     return 0;
  484.    }
  485.    Buff++;
  486.    /* create a new tree structure to hold this kinetic type            */
  487.    eqefl = 0;
  488.    new_tree( nudf );
  489.    /* get another tree from the buffer                                */
  490.    if( (Buff = BufToTree( Buff ) ) == NULL )
  491.    {
  492.     LocalUnlock( hBuff );
  493.     LocalFree( hBuff );
  494.     return IDS_ERR_DATAB_CORRUPT;
  495.    }
  496.    /* copy the tree structure to the permanent storage                */
  497.    _fmemcpy( (void __far *) &tree[nudf-1], (void __far *) &tr, sizeof( struct treet ) );
  498.    /* store the new type in ktype                                    */
  499.    GlobalUnlock( hKtype );
  500.    hTemp = GlobalReAlloc( hKtype, (DWORD) (nrateq+1) * sizeof( struct kint ), GMEM_ZEROINIT | GMEM_MOVEABLE );
  501.    if( hTemp != NULL )
  502.    {
  503.     hKtype = hTemp;
  504.     ktype = ( struct kint huge * ) GlobalLock( hKtype );
  505.     ktype[nrateq].nsub = (unsigned char) tree[nudf-1].nsub;
  506.     ktype[nrateq].npro = (unsigned char) tree[nudf-1].npro;
  507.     ktype[nrateq].revers = (unsigned char) tree[nudf-1].revers;
  508.     ktype[nrateq].nmodf = (unsigned char) tree[nudf-1].nmodf;
  509.     ktype[nrateq].descr = (LPSTR) tree[nudf-1].descr;
  510.     nrateq++;
  511.    }
  512.    else
  513.    {
  514.     ktype = ( struct kint huge * ) GlobalLock( hKtype );
  515.     LocalUnlock( hBuff );
  516.     LocalFree( hBuff );
  517.     return IDS_ERR_NOEXEC;
  518.    }
  519.   }
  520.  }
  521.  else return 0; /*IDS_ERR_LOAD;*/
  522. }
  523.  
  524. /*
  525.    write the user-defined kinetic types in the database
  526. */
  527.  
  528. int out_tree( void )
  529. {
  530.  char Buff[5500];
  531.  int ch1;
  532.  OFSTRUCT OfStruct;
  533.  char fn[128], *ptr;
  534.  int i;
  535.  
  536.  /* make the complete pathname of user-def.kin            */
  537.  GetModuleFileName( hInst, (LPSTR) fn, sizeof( fn ) );
  538.  ptr = strrchr( fn, '\\' );
  539.  *(ptr+1) = '\0';
  540.  lstrcat( (LPSTR) fn, (LPSTR) "user-def.kin" );
  541.  
  542.  /* first create the file                                                */
  543.  if( (ch1 = OpenFile( fn, &OfStruct, OF_CREATE | OF_WRITE )) == -1 )
  544.   return IDS_ERR_SAVE;
  545.  close( ch1 );
  546.  
  547.  /* for all user-defined kinetic types                                    */
  548.  for( i=0; i<nudf; i++ )
  549.  {
  550.   /* write the tree function to the buffer                                */
  551.   TreeToBuf( i, (LPSTR) Buff );
  552.   /* reopen the file and write this tree to it                            */
  553.   if( (ch1 = OpenFile( (LPSTR) NULL, &OfStruct, OF_REOPEN | OF_WRITE )) != -1 )
  554.   {
  555.    /* write the buffer to the file and close it                            */
  556.    _lseek( ch1, (LONG) 0, 2 );
  557.    _lwrite( ch1, (LPSTR) Buff, (WORD) strlen( Buff ) );
  558.    _lclose( ch1 );
  559.   }
  560.   if( ch1 == -1 ) return IDS_ERR_SAVE;
  561.  }
  562.  return 0;
  563. }
  564.  
  565.  
  566. /*
  567.   add a user-defined rate equation to the database
  568. */
  569.  
  570. int new_rateq( int idx )
  571. {
  572.  GLOBALHANDLE hTemp;
  573.  
  574.  /* unlock the memory handle    */
  575.  GlobalUnlock( hKtype );
  576.  hTemp = GlobalReAlloc( hKtype, (DWORD) (nrateq+1) * sizeof( struct kint ), GMEM_ZEROINIT | GMEM_MOVEABLE );
  577.  if( hTemp != NULL )
  578.  {
  579.   hKtype = hTemp;
  580.   ktype = ( struct kint huge * ) GlobalLock( hKtype );
  581.   ktype[MAX_TYP+idx].nsub = (unsigned char) tree[idx].nsub;
  582.   ktype[MAX_TYP+idx].npro = (unsigned char) tree[idx].npro;
  583.   ktype[MAX_TYP+idx].revers = (unsigned char) tree[idx].revers;
  584.   ktype[MAX_TYP+idx].nmodf = (unsigned char) tree[idx].nmodf;
  585.   ktype[MAX_TYP+idx].descr = (LPSTR) tree[idx].descr;
  586.   if( !eqefl ) nrateq++;
  587.   return 0;
  588.  }
  589.  else
  590.  {
  591.   ktype = ( struct kint huge * ) GlobalLock( hKtype );
  592.   return IDS_ERR_NOEXEC;
  593.  }
  594. }
  595.  
  596.  
  597. /*
  598.   free global heap space allocated
  599. */
  600.  
  601. void TidyGepasiVar( void )
  602. {
  603.  GlobalUnlock( hMetname );                            /* unlock all global handles    */
  604.  GlobalUnlock( hStepname );
  605.  GlobalUnlock( hStoiu );
  606.  GlobalUnlock( hLoop );
  607.  GlobalUnlock( hRstr );
  608.  GlobalUnlock( hKtype );
  609.  GlobalUnlock( hTree );
  610.  
  611.  GlobalFree( hMetname );                            /* free all global mem blocks    */
  612.  GlobalFree( hStepname );
  613.  GlobalFree( hStoiu );
  614.  GlobalFree( hLoop );
  615.  GlobalFree( hRstr );
  616.  GlobalFree( hKtype );
  617.  GlobalFree( hTree );
  618. }
  619.  
  620.  
  621.